7. Estructuras de control.
Las estructuras de control,
permiten tomar decisiones y realizar un proceso repetidas veces. Son los
denominados bifurcaciones y bucles. Este tipo de estructuras son comunes en cuanto
a concepto en la mayoría de los lenguajes de programación, aunque su sintaxis
puede variar de un lenguaje de programación a otro. Se trata de unas
estructuras muy importantes ya que son las encargadas de controlar el flujo de
un programa según los requerimientos del mismo.
7.1. Sentencia IF ... THEN ... ELSE
...
Esta estructura permite ejecutar
condicionalmente una o más sentencias y puede escribirse de dos formas. La
primera ocupa sólo una línea y tiene la forma siguiente:
If condicion
Then sentencia1 [Else sentencia2]
La
segunda es más general y se muestra a continuación:
El código sería:
If condicion
Then
sentencia(s)
[Else
sentencia(s)]
End
If
O sea, si condicion
es True (verdadera), se ejecutan las sentencias que están
a continuación de Then, y si condicion es False
(falsa), se ejecutan las sentencias que están a continuación de Else,
si esta cláusula ha sido especificada (pues es opcional). Para indicar que se
quiere ejecutar uno de varios bloques de sentencias dependientes cada uno de
ellos de una condición, la estructura adecuada es la siguiente:
If condicion1 Then
sentencias1
ElseIf
condicion2 Then
sentencias2
Else
sentencia-n
End If
Si se cumple la condicion1 se
ejecutan las sentencias1, y si no se cumple, se examinan
secuencialmente las condiciones siguientes hasta Else,
ejecutándose las sentencias correspondientes al primer ElseIf cuya
condición se cumpla. Si todas las condiciones son falsas, se ejecutan las
sentencias-n correspondientes a Else, que es la opción por
defecto.
7.2. Sentencia SELECT CASE
Esta sentencia permite ejecutar una
de entre varias acciones en función del valor de una expresión. Es una
alternativa a If ... Then ... ElseIf cuando se compara
la misma expresión con diferentes valores. Su forma general es la siguiente:
El
código sería:
Select Case expresion
Case etiq1
[sentencias1]
Case etiq2
[sentencias2]
Case Else
sentenciasn
End Select
donde expresion es
una expresión numérica o alfanumérica, y etiq1, etiq2,
... pueden adoptar las formas siguientes:
1.
expresion
2.
expresion To expresion
3. Is operador-de-relación
expresion
4. combinación de las anteriores
separadas por comas
Cuando se utiliza la forma expresion
To expresion, el valor más pequeño debe aparecer en primer lugar.
Cuando se ejecuta una sentencia Select Case, Visual Basic evalúa
la expresion y el control del programa se transfiere a la
sentencia cuya etiqueta tenga el mismo valor que la expresión evaluada,
ejecutando a continuación el correspondiente bloque de sentencias. Si no existe
un valor igual a la expresion entonces se ejecutan las sentencias
a continuación de Case Else.
7.3. Sentencia FOR ... NEXT
La sentencia For da lugar
a un lazo o bucle, y permite ejecutar un conjunto de sentencias cierto número
de veces. Su forma general es:
El código sería:
For variable
= expresion1 To expresion2 [Step expresion3]
[sentencias]
Exit For
[sentencias]
Next
[variable]
Cuando se
ejecuta una sentencia For, primero se asigna el valor de la expresion1
a la variable y se comprueba si su valor es mayor o menor que la expresion2.
En caso de ser menor se ejecutan las sentencias, y en caso de ser mayor el
control del programa salta a las líneas a continuación de Next.
Todo esto sucede en caso de ser la expresion3 positiva. En caso
contrario se ejecutarán las sentencias cuando la variable sea mayor que expresion2.
Una vez ejecutadas las sentencias, la variable se incrementa en el valor de
la expresion3, o en 1 si Step no se especifica,
volviéndose a efectuar la comparación entre la variable y la expresion2,
y así sucesivamente.
La
sentencia Exit For es opcional y permite salir de un bucle For
... Next antes de que éste finalice.
7.4. Sentencia DO ... LOOP
Un Loop (bucle) repite
la ejecución de un conjunto de sentencias mientras una condición dada sea
cierta, o hasta que una condición dada sea cierta. La condición puede ser
verificada antes o después de ejecutarse el conjunto de sentencias. Sus
posibles formas son las siguientes:
El código sería:
-
Formato 1:
Do
[{While/Until} condicion]
[sentencias]
[Exit
Do]
[sentencias]
Loop
-
Formato 2:
Do
[sentencias]
[Exit
Do]
[sentencias]
Loop [{While/Until}condicion]
La sentencia opcional Exit Do permite
salir de una bucle Do ... Loop antes de que finalice éste.
7.5. Sentencia WHILE … WEND
Esta sentencia es otra forma de
generar bucles que se recorren mientras se cumpla la condición inicial. Su
estructura es la siguiente:
El código sería:
While condicion
[sentencias]
Wend
7.6. Sentencia FOR EACH ... NEXT
Esta construcción es similar al
bucle For, con la diferencia de que la variable que controla la
repetición del bucle no toma valores entre un mínimo y un máximo, sino a partir
de los elementos de un array (o de una colección de objetos). La forma general
es la siguiente:
El código sería:
For Each variable In grupo
[sentencias]
Next variable
Con arrays variable tiene que
ser de tipo Variant. Con colecciones variable puede ser Variant
o una variable de tipo Object. Esta construcción es muy útil
cuando no se sabe el número de elementos que tiene el array o la
colección de objetos.
Cuando se sabe que se va a ejecutar
las sentencias un número determinado de veces, es mejor elegir el bucle For...Next.
A diferencia del bucle Do, el bucle For utiliza una variable
llamada contador que incrementa o reduce su valor en cada repetición del bucle.
La sintaxis es la siguiente:
For contador = iniciar To finalizar [Step incremento]
Sentencias
Next [contador]
Los argumentos contador, iniciar,
finalizar e incremento son todos numéricos.
Nota: El argumento incremento puede
ser positivo o negativo. Si incremento es positivo, iniciar debe ser menor o
igual que finalizar o no se ejecutarán las sentencias del bucle. Si incremento
es negativo, iniciar debe ser mayor o
igual que finalizar para que se ejecute el cuerpo del bucle. Si no se establece
Step, el valor predeterminado de incremento es 1. Al ejecutar el bucle For, Visual
Basic:
1. Establece contador al mismo valor que
iniciar.
2. Comprueba si contador es mayor que
finalizar. Si lo es, Visual Basic sale del bucle. (Si incremento es negativo,
Visual Basic comprueba si contador es menor que finalizar.)
3. Ejecuta las sentencias.
4. Incrementa contador en 1 o en
incremento, si se especificó.
5. Repite los pasos 2 a 4.
